import { localStg } from '@/utils';
import Taro from '@tarojs/taro';
import { EventManager, EVENT_NAMES } from '@/utils/eventManager';

/**
 * 平台判断工具类
 */
export class PlatformUtils {
    /**
     * 判断当前平台是否为安好
     * 根据 sysOrgCode 前6位判断：A01A03 是安好，其他是华声
     * @returns {boolean} true-安好平台，false-华声平台
     */
    static isAnHao(): boolean {
        try {
            // 优先从 defaultHospital 对象中获取 sysOrgCode
            const defaultHospital = JSON.parse(Taro.getStorageSync('defaultHospital') || '{}');
            const sysOrgCode = defaultHospital?.sysOrgCode || localStg.get('sys_org_code') || '';

            // 根据 sysOrgCode 前6位判断：A01A03 是安好，其他是华声
            return sysOrgCode.substring(0, 6) === 'A01A03';
        } catch (error) {
            // 默认返回华声平台
            return false;
        }
    }

    /**
     * 获取当前医院对象
     * @returns {object} 医院对象，包含 id、name、sysOrgCode 等属性
     */
    static getDefaultHospital(): any {
        try {
            const defaultHospital = JSON.parse(Taro.getStorageSync('defaultHospital') || '{}');
            return defaultHospital;
        } catch (error) {
            return {};
        }
    }

    /**
     * 获取当前医院ID
     * @returns {string} 医院ID
     */
    static getHospitalId(): string {
        const hospital = this.getDefaultHospital();
        return hospital?.id || '';
    }

    /**
     * 获取当前医院名称
     * @returns {string} 医院名称
     */
    static getHospitalName(): string {
        const hospital = this.getDefaultHospital();
        return hospital?.name || '';
    }

    /**
     * 判断当前平台是否为华声
     * @returns {boolean} true-华声平台，false-安好平台
     */
    static isHuaSheng(): boolean {
        return !this.isAnHao();
    }

    /**
     * 获取当前平台名称
     * @returns {string} '安好' 或 '华声'
     */
    static getPlatformName(): string {
        return this.isAnHao() ? '安好' : '华声';
    }

    /**
     * 获取当前平台的 sysOrgCode
     * @returns {string} sysOrgCode 字符串
     */
    static getSysOrgCode(): string {
        try {
            const defaultHospital = JSON.parse(Taro.getStorageSync('defaultHospital') || '{}');
            return defaultHospital?.sysOrgCode || localStg.get('sys_org_code') || '';
        } catch (error) {
            return '';
        }
    }
}

/**
 * 医院数据监听器
 */
export class HospitalWatcher {
    private static listeners: Array<(hospital: any) => void> = [];
    private static lastHospitalData: string = '';
    private static checkInterval: number | null = null;

    /**
     * 添加医院数据变化监听器
     * @param callback 回调函数，参数为医院对象
     */
    static addListener(callback: (hospital: any) => void): void {
        this.listeners.push(callback);
        
        // 如果还没有开始监听，则开始监听
        if (!this.checkInterval) {
            this.startWatching();
        }
    }

    /**
     * 移除医院数据变化监听器
     * @param callback 要移除的回调函数
     */
    static removeListener(callback: (hospital: any) => void): void {
        const index = this.listeners.indexOf(callback);
        if (index > -1) {
            this.listeners.splice(index, 1);
        }
        
        // 如果没有监听器了，停止监听
        if (this.listeners.length === 0) {
            this.stopWatching();
        }
    }

    /**
     * 开始监听医院数据变化
     */
    private static startWatching(): void {
        // 初始化当前数据
        this.lastHospitalData = JSON.stringify(PlatformUtils.getDefaultHospital());
        
        // 每500ms检查一次数据变化
        this.checkInterval = setInterval(() => {
            const currentHospitalData = JSON.stringify(PlatformUtils.getDefaultHospital());
            
            // 如果数据发生变化
            if (currentHospitalData !== this.lastHospitalData) {
                // 更新缓存的数据
                this.lastHospitalData = currentHospitalData;
                
                // 通知所有监听器
                const hospital = PlatformUtils.getDefaultHospital();
                this.listeners.forEach(callback => {
                    try {
                        callback(hospital);
                    } catch (error) {
                        // 医院数据变化监听器执行失败
                    }
                });

                // 发布全局事件
                EventManager.emit(EVENT_NAMES.HOSPITAL_CHANGE, hospital);
                EventManager.emit(EVENT_NAMES.SYS_ORG_CHANGE, {
                    sysOrgCode: hospital?.sysOrgCode,
                    hospitalId: hospital?.id,
                    hospitalName: hospital?.name
                });
            }
        }, 2000) as any;
    }

    /**
     * 停止监听医院数据变化
     */
    private static stopWatching(): void {
        if (this.checkInterval) {
            clearInterval(this.checkInterval);
            this.checkInterval = null;
        }
    }

    /**
     * 手动触发一次数据检查
     */
    static triggerCheck(): void {
        const currentHospitalData = JSON.stringify(PlatformUtils.getDefaultHospital());
        if (currentHospitalData !== this.lastHospitalData) {
            this.lastHospitalData = currentHospitalData;
            const hospital = PlatformUtils.getDefaultHospital();
            this.listeners.forEach(callback => {
                try {
                    callback(hospital);
                } catch (error) {
                    // 医院数据变化监听器执行失败
                }
            });
        }
    }

    /**
     * 清除所有监听器
     */
    static clearAllListeners(): void {
        this.listeners = [];
        this.stopWatching();
    }
}

/**
 * 渠道工具类
 */
export class ChannelUtils {
    static setShopId(value: string) {
        localStg.set('shopid', value);
    }

    static getShopId(): string {
        return localStg.get('shopid') || '';
    }

    static clearShopId(): void {
        localStg.remove('shopid');
    }

    /**
     * 获取渠道ID
     */
    static getChannelId(): string {
        return localStg.get('qudaoid') || '';
    }

    /**
     * 设置渠道ID
     */
    static setChannelId(channelId: string): void {
        localStg.set('qudaoid', channelId);
    }

    /**
     * 清除渠道ID
     */
    static clearChannelId(): void {
        localStg.remove('qudaoid');
    }

    /**
     * 检查是否来自第三方渠道
     */
    static isFromThirdParty(): boolean {
        return !!this.getChannelId();
    }

    /**
     * 获取渠道信息用于上报
     */
    static getChannelInfo() {
        const channelId = this.getChannelId();
        return {
            channelId,
            isFromThirdParty: !!channelId,
            timestamp: Date.now()
        };
    }
}

/**
 * 渠道常量
 */
export const CHANNEL_CONSTANTS = {
    // 渠道ID映射
    CHANNEL_NAMES: {
        '0773020': '第三方渠道1',
        '0773021': '第三方渠道2',
        // 可以添加更多渠道映射
    }
} as const;

/**
 * 获取渠道名称
 */
export function getChannelName(channelId: string): string {
    return CHANNEL_CONSTANTS.CHANNEL_NAMES[channelId as keyof typeof CHANNEL_CONSTANTS.CHANNEL_NAMES] || '未知渠道';
}



/**
 * 发布医院变化事件的工具函数
 */
export function emitHospitalChangeEvent(hospital?: any) {
    const hospitalData = hospital || PlatformUtils.getDefaultHospital();
    EventManager.emit(EVENT_NAMES.HOSPITAL_CHANGE, hospitalData);
    EventManager.emit(EVENT_NAMES.SYS_ORG_CHANGE, {
        sysOrgCode: hospitalData?.sysOrgCode,
        hospitalId: hospitalData?.id,
        hospitalName: hospitalData?.name
    });
}

/**
 * 设置医院并发送变化事件
 * @param hospital 医院对象
 */
export function setHospitalAndEmitEvent(hospital: any) {
    // 写入缓存
    Taro.setStorageSync('defaultHospital', JSON.stringify(hospital));
    
    // 发送医院变化事件
    emitHospitalChangeEvent(hospital);
}
